"""
作业：
一、定义一个学生Student类。有下面的类属性：
1 姓名 name
2 年龄 age
3 成绩 score（语文，数学，英语) [每课成绩的类型为整数]
类方法：
 1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
4 将每个实例学生对象写进txt文件里，要持久保存
举例：{"姓名":"a","年龄":29,"成绩":{"语文":99,"数学":100,"英语":85}
5 获取所有学生的信息
写好类以后，可以定义2个同学测试下:
zm = Student('zhangming',20,[69,88,100])
二、定义一个字典类：dictclass。完成下面的功能：
1 删除某个key
2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
3 返回键组成的列表：返回类型;(list)
4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
四、定义一个列表的操作类：Listinfo
包括的方法:
1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list) [list:列表类型]
4 删除并且返回最后一个元素：del_key()
 五、做一个学生点名系统，系统里支持：存入学生、更改学生、删除学生、点到学生姓名方法
存入学生（姓名、年龄、家庭地址、手机号）： 存入成功后，提示xxx存入成功
更改学生（姓名、年龄、家庭地址、手机号）：可以修改学生内容的任意一个字段
删除学生：删除的学生将不在展示
展示全部学生：可以看到全部的学生姓名
学生姓名：随机抽取任意一个存在的学生信息，然后打印：到！。举例： 刘闯到！
六、点餐管理系统
1》、餐馆可以新增菜品、下架菜品、修改菜品
2》、每个菜品，都有对应的库存，所有菜品的库存均为999，每出一道菜，库存-1
菜品有对应的价格，餐厅老板定义价格每道菜不允许超过15元，没有小数单位，均为整数
3》、餐馆后台有点赞系统，能够收集客户对菜品的喜好，0~5分
4》、有菜品评分提报功能，对平均分数（菜品总分/打分人数）低于3分的菜品进行强制下架；
 七、定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，
包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，
并调用showInfo方法，输出每个桌子的信息。
八、定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。
九、定义一个计算器类，有加减乘除四个方法
十、创建一个名为Person的类，具有以下属性和方法：
属性：name（姓名），age（年龄）
方法：greet()，打印出一句问候语，包括该人的姓名和年龄
十一、定义一个图书管理系统类，图书可以新增、修改、删除，要求新增的每个图书都加到txt文本里，数据持久化
新增：图书名、作者名称、新建年月日
修改：图书名、作者名称、新建年月日
删除：图书删掉，且不在展示
查看：全量查询，精确查询，需要用户传入形参来控制返回结果
十二、创建一个名为"Car"的类，该类具有"品牌"和"颜色"属性。
创建一个"start_engine"方法，该方法打印出"启动汽车引擎！"的消息。
创建一个"stop_engine"方法，该方法打印出"关闭汽车引擎！"的消息
十三、淘宝商家后台，可以上架商品、下架商品，功能如下：
 （1） 可以添加商品，商家添加完的商品会存到商品列表
 1.1  商品要有名称、sku、价格
 （2） 可以修改商品信息：名称、sku、价格
 （3） 可以对商品进行下架，下架后的商品不再展示
十四、定义一个人类
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤
十五、士兵瑞恩有一把ak47
士兵可以开火（开火扣动的是扳机）
枪能够发射子弹（把子弹打出去）
抢能够装子弹–增加子弹数量
要求没子弹，需要输出没有子弹了，且发射失败
"""
# 作业一
"""
一、定义一个学生Student类。有下面的类属性：
1 姓名 name
2 年龄 age
3 成绩 score（语文，数学，英语) [每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回3门科目中最高的分数。get_course() 返回类型:int
4 将每个实例学生对象写进txt文件里，要持久保存
举例：{"姓名":"a","年龄":29,"成绩":{"语文":99,"数学":100,"英语":85}
5 获取所有学生的信息
写好类以后，可以定义2个同学测试下:
zm = Student('zhangming',20,[69,88,100])
"""
# 答案
"""
class Student():
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
        with open("studnet.txt",'a',encoding='utf-8') as f:
            f.write(f"姓名:{self.name} 年龄:{self.age} 成绩:{self.score}")
    def course(self):
        print('course')

    def get_name(self):
        return self.name

    def get_age(self):
        return self.age
    def get_course(self):
        return max(self.score)


zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_course())
"""
# 作业二
"""
二、定义一个字典类：dictclass。完成下面的功能：
1 删除某个key
2 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
3 返回键组成的列表：返回类型;(list)
4 合并字典，并且返回合并后字典的values组成的列表。返回类型:(list)
"""
# 答案
"""
class Dictclass:
    def __init__(self, my_dict):
        self.my_dict = my_dict

    def delete_key(self, key):
        
        # 删除指定的key
        
        if key in self.my_dict:
            del self.my_dict[key]
            print("删除成功")
        else:
            print("Key not found.")

    def find_key(self, key):
        
        # 判断某个键是否在字典里，如果在返回键对应的值，不存在则返回"not found"
        
        return self.my_dict.get(key, "not found")

    def get_keys(self):
        
        # 返回键组成的列表
       
        return list(self.my_dict.keys())

    def merge_dicts(self, other_dict):
       
        # 合并字典，并且返回合并后字典的values组成的列表
        
        self.my_dict.update(other_dict)
        return list(self.my_dict.values())

my_dict = {'a': 1, 'b': 2, 'c': 3}
dict1 = Dictclass(my_dict)

dict1.delete_key('a')
print(dict1.my_dict)#{'b': 2, 'c': 3}

value = dict1.find_key('a')
print(value)  # 输出：not found

keys_list = dict1.get_keys()
print(keys_list)  # 输出：['b', 'c']

other_dict = {'d': 4, 'e': 5}
merged_values = dict1.merge_dicts(other_dict)
print(merged_values)  # 输出：[2, 3, 4, 5]
"""
# 作业四
"""
四、定义一个列表的操作类：Listinfo
包括的方法:
1 列表元素添加: add_key(keyname) [keyname:字符串或者整数类型]
2 列表元素取值：get_key(num) [num:整数类型]
3 列表合并：update_list(list) [list:列表类型]
4 删除并且返回最后一个元素：del_key()
"""
# 答案
"""
class ListInfo:
    def __init__(self, my_list):
        self.my_list = my_list

    def add_key(self, keyname):
        
        # 列表元素添加
        
        self.my_list.append(keyname)

    def get_key(self, num):
      
        # 列表元素取值

        if 0 <= num < len(self.my_list):
            return self.my_list[num]
        else:
            print("Index out of range.")

    def update_list(self, new_list):
      
        # 列表合并
     
        if isinstance(new_list, list):
            self.my_list.extend(new_list)
        else:
            print("Input is not a list.")

    def del_key(self):
       
        # 删除并且返回最后一个元素
        if len(self.my_list) > 0:
            return self.my_list.pop()
        else:
            print("List is empty.")

# 示例用法
my_list = [1, 2, 3]
list_info = ListInfo(my_list)

list_info.add_key(4)
print(list_info.my_list)  # 输出：[1, 2, 3, 4]

value = list_info.get_key(2)
print(value)  # 输出：3

new_list = [5, 6]
list_info.update_list(new_list)
print(list_info.my_list)  # 输出：[1, 2, 3, 4, 5, 6]

last_element = list_info.del_key()
print(last_element)  # 输出：6
print(list_info.my_list)  # 输出：[1, 2, 3, 4, 5]

"""
# 作业五
"""
五、做一个学生点名系统，系统里支持：存入学生、更改学生、删除学生、点到学生姓名方法
存入学生（姓名、年龄、家庭地址、手机号）： 存入成功后，提示xxx存入成功
更改学生（姓名、年龄、家庭地址、手机号）：可以修改学生内容的任意一个字段
删除学生：删除的学生将不在展示
展示全部学生：可以看到全部的学生姓名
学生姓名：随机抽取任意一个存在的学生信息，然后打印：到！。举例： 刘闯到！
"""
# 答案
"""
import random

class StudentAttendanceSystem:
    def __init__(self):
        self.students = []

    def add_student(self, name, age, address, phone):
        
        # 存入学生

        student = {'name': name, 'age': age, 'address': address, 'phone': phone}
        self.students.append(student)
        print(f"{name}存入成功.")

    def update_student(self, name, field, new_value):
      
        # 更改学生
     
        for student in self.students:
            if student['name'] == name:
                student[field] = new_value
                print(f"{name}的{field}已更新为{new_value}.")
                return
        print(f"{name}不存在.")

    def delete_student(self, name):
        
        # 删除学生

        for student in self.students:
            if student['name'] == name:
                self.students.remove(student)
                print(f"{name}已删除.")
                return
        print(f"{name}不存在.")

    def show_all_students(self):
       
        # 展示全部学生
      
        print("全部学生姓名:")
        for student in self.students:
            print(student['name'])

    def call_student(self):
        
        # 学生点名
        
        if not self.students:
            print("学生列表为空.")
            return

        random_student = random.choice(self.students)
        print(f"{random_student['name']}到！")


system = StudentAttendanceSystem()

system.add_student("张三", 20, "北京", "1234567890")
system.add_student("李四", 22, "上海", "9876543210")
system.add_student("王五", 21, "广州", "1357924680")

system.show_all_students()

system.update_student("张三", "age", 21)
system.show_all_students()

system.delete_student("李四")
system.show_all_students()

system.call_student()
"""
# 作业六
"""
六、点餐管理系统
1》、餐馆可以新增菜品、下架菜品、修改菜品
2》、每个菜品，都有对应的库存，所有菜品的库存均为999，每出一道菜，库存-1
菜品有对应的价格，餐厅老板定义价格每道菜不允许超过15元，没有小数单位，均为整数
3》、餐馆后台有点赞系统，能够收集客户对菜品的喜好，0~5分
4》、有菜品评分提报功能，对平均分数（菜品总分/打分人数）低于3分的菜品进行强制下架;
"""
# 答案
"""
class Restaurant:
    def __init__(self):
        self.menu = {}
        self.inventory = {}
        self.likes = {}
        self.scores = {}

    def add_dish(self, name, price):
        
        # 新增菜品
        
        if price > 15:
            print("菜品价格不能超过15元.")
            return

        self.menu[name] = price
        self.inventory[name] = 999
        self.likes[name] = []
        self.scores[name] = {'total_score': 0, 'num_scores': 0}

        print(f"菜品{name}添加成功.")

    def remove_dish(self, name):
       
        # 下架菜品
        
        if name in self.menu:
            del self.menu[name]
            del self.inventory[name]
            del self.likes[name]
            del self.scores[name]
            print(f"菜品{name}已下架.")
        else:
            print(f"菜品{name}不存在.")

    def modify_dish(self, name, new_price):
       
        # 修改菜品
        
        if name in self.menu:
            if new_price <= 15:
                self.menu[name] = new_price
                print(f"菜品{name}价格已修改为{new_price}元.")
            else:
                print("菜品价格不能超过15元.")
        else:
            print(f"菜品{name}不存在.")

    def order_dish(self, name):
        
        # 下单，减少库存
        
        if name in self.menu and self.inventory[name] > 0:
            self.inventory[name] -= 1
            print(f"下单成功，{name}库存剩余{self.inventory[name]}份.")
        else:
            print(f"菜品{name}已售罄.")

    def like_dish(self, name, rating):
        
        # 客户点赞
        
        if name in self.menu and 0 <= rating <= 5:
            self.likes[name].append(rating)
            print(f"对菜品{name}的喜好评分已记录.")
        else:
            print("评分失败，请检查菜品是否存在且评分在0~5分之间.")

    def report_low_scores(self):
        
        # 菜品评分提报功能
        
        for name, score_info in self.scores.items():
            if score_info['num_scores'] > 0 and (score_info['total_score'] / score_info['num_scores']) < 3:
                print(f"菜品{name}的平均评分低于3分，已强制下架.")
                self.remove_dish(name)


restaurant = Restaurant()

restaurant.add_dish("宫保鸡丁", 12)
restaurant.add_dish("麻辣香锅", 15)
restaurant.add_dish("水煮鱼", 14)

restaurant.like_dish("宫保鸡丁", 4)
restaurant.like_dish("宫保鸡丁", 5)
restaurant.like_dish("宫保鸡丁", 2)

restaurant.report_low_scores()

restaurant.order_dish("宫保鸡丁")
restaurant.order_dish("宫保鸡丁")
restaurant.order_dish("宫保鸡丁")

restaurant.report_low_scores()
"""
# 作业七
"""
七、定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，
包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，
并调用showInfo方法，输出每个桌子的信息。
"""
# 答案
"""
class Desk:
    def __init__(self,length,width,height):
        self.length = length
        self.width = width
        self.height = height

    def showInfo(self):
        return f"桌子长{self.length} 桌子宽{self.width} 桌子高{self.height}"

desk1 = Desk(10,20,30)
desk2 = Desk(50,20,40)
print(desk1.showInfo())
print(desk2.showInfo())
"""
# 作业八
"""
八、定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。
"""
# 答案
"""
class User:
    def __init__(self,username,password):
        self.username = username
        self.password = password

user1 = User(username="john_doe", password="password123")


print("Username:", user1.username)
print("Password:", user1.password)
"""
# 作业九
"""
九、定义一个计算器类，有加减乘除四个方法
"""
# 答案
"""
class Calculator:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2

    def add_num(self):
        return self.num1 + self.num2

    def subtract_num(self):
        return self.num1 - self.num2

    def multiply_num(self):
        return self.num1 * self.num2

    def divide_num(self):
        if self.num2!=0:
            return self.num1 / self.num2
        else:
            return "逻辑错误"

num = Calculator(5,2)
print(num.add_num())
print(num.subtract_num())
print(num.multiply_num())
print(num.divide_num())
"""
# 作业十
"""
十、创建一个名为Person的类，具有以下属性和方法：
属性：name（姓名），age（年龄）
方法：greet()，打印出一句问候语，包括该人的姓名和年龄
"""
# 答案
"""
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def greet(self):
        return f"您好,我的名字是{self.name},年龄是{self.age}"
person = Person("魏彦旭",23)
print(person.greet())
"""
# 作业十一
"""
十一、定义一个图书管理系统类，图书可以新增、修改、删除，要求新增的每个图书都加到txt文本里，数据持久化
新增：图书名、作者名称、新建年月日
修改：图书名、作者名称、新建年月日
删除：图书删掉，且不在展示
查看：全量查询，精确查询，需要用户传入形参来控制返回结果
"""
# 答案
"""
import os
import datetime

class BookManagementSystem:
    def __init__(self, data_file='books.txt'):
        self.data_file = data_file
        self.books = self.load_books()

    def load_books(self):
        if os.path.exists(self.data_file):
            with open(self.data_file, 'r') as file:
                lines = file.readlines()
                books = [line.strip().split(',') for line in lines]
                return books
        else:
            return []

    def save_books(self):
        with open(self.data_file, 'w') as file:
            for book in self.books:
                file.write(','.join(book) + '\n')

    def add_book(self, title, author):
        date_added = datetime.datetime.now().strftime('%Y-%m-%d')
        new_book = [title, author, date_added]
        self.books.append(new_book)
        self.save_books()

    def modify_book(self, old_title, old_author, new_title, new_author):
        for book in self.books:
            if book[0] == old_title and book[1] == old_author:
                book[0] = new_title
                book[1] = new_author
                book[2] = datetime.datetime.now().strftime('%Y-%m-%d')
                self.save_books()
                return True
        return False

    def delete_book(self, title, author):
        self.books = [book for book in self.books if not (book[0] == title and book[1] == author)]
        self.save_books()

    def view_books(self, mode='all', title=None, author=None):
        if mode == 'all':
            return self.books
        elif mode == 'exact':
            return [book for book in self.books if book[0] == title and book[1] == author]
        else:
            return "Invalid view mode. Please use 'all' or 'exact'."


book_system = BookManagementSystem()
book_system.add_book('The Great Gatsby', 'F. Scott Fitzgerald')
book_system.modify_book('The Great Gatsby', 'F. Scott Fitzgerald', 'New Title', 'New Author')
book_system.delete_book('New Title', 'New Author')
all_books = book_system.view_books()
exact_books = book_system.view_books(mode='exact', title='The Great Gatsby', author='F. Scott Fitzgerald')
print("All Books:", all_books)
print("Exact Books:", exact_books)
"""
# 作业十二
"""
十二、创建一个名为"Car"的类，该类具有"品牌"和"颜色"属性。
创建一个"start_engine"方法，该方法打印出"启动汽车引擎！"的消息。
创建一个"stop_engine"方法，该方法打印出"关闭汽车引擎！"的消息
"""
# 答案
"""
class Car:
    def __init__(self,type_car,color_car):
        self.type_car = type_car
        self.color_car = color_car
    def start_engine(self):
        print("启动汽车引擎！")
    def stop_engine(self):
        print("关闭汽车引擎！")

car = Car('BMW','blue')
car.start_engine()
car.stop_engine()
"""
# 作业十三
"""
十三、淘宝商家后台，可以上架商品、下架商品，功能如下：
 （1） 可以添加商品，商家添加完的商品会存到商品列表
 1.1  商品要有名称、sku、价格
 （2） 可以修改商品信息：名称、sku、价格
 （3） 可以对商品进行下架，下架后的商品不再展示
"""
# 答案
"""
class Taobao:
    def __init__(self,trade_name,sku,commodity_price):
        self.trade_name = trade_name
        self.sku = sku
        self.commodity_price = commodity_price
        self.is_on_sale = True

    def display_info(self):
        print(
            f"商品名称: {self.trade_name}, SKU: {self.sku}, 价格: {self.commodity_price}, 上架状态: {'上架' if self.is_on_sale else '下架'}")

    def modify_product(self, new_trade_name=None, new_sku=None, new_commodity_price=None):
        if new_trade_name:
            self.trade_name = new_trade_name
        if new_sku:
            self.sku = new_sku
        if new_commodity_price:
            self.commodity_price = new_commodity_price
        print("商品信息已成功修改。")
        self.display_info()

    def take_off_shelves(self):
        self.is_on_sale = False
        print("商品已成功下架。")
        self.display_info()

# 创建淘宝商家后台实例
taobao_product = Taobao("手机", "SKU001", 1999.99)
# 查看商品信息
taobao_product.display_info()

# 修改商品信息
taobao_product.modify_product(new_trade_name="新手机", new_commodity_price=2199.99)

# 下架商品
taobao_product.take_off_shelves()
"""
# 作业十四
"""
十四、定义一个人类
1.小明和小美都爱跑步
2.小美体重45.0公斤
3.小明体重75.0公斤
4.每次跑步都会减少0.5公斤
5.每次吃东西都会增加1公斤
"""
# 答案
"""
class Person:
    def __init__(self,name,weight):
        self.name = name
        self.weight = weight
    def run_person(self):
        self.weight -= 0.5
        return f"{self.name}的体重是{self.weight}"
    def eat_person(self):
        self.weight += 1
        return f"{self.name}的体重是{self.weight}"
xm = Person("小明",75.0)
xh = Person("小红",45.0)
print(xm.run_person())
print(xh.eat_person())
"""
# 作业十五
"""
十五、士兵瑞恩有一把ak47
士兵可以开火（开火扣动的是扳机）
枪能够发射子弹（把子弹打出去）
抢能够装子弹–增加子弹数量
要求没子弹，需要输出没有子弹了，且发射失败
"""
# 答案
"""
class Ak47:
    def __init__(self):
        self.bullets = 0

    def load_bullets(self, num_bullets):
        self.bullets += num_bullets
        print(f"装载了 {num_bullets} 发子弹，当前弹夹中共有 {self.bullets} 发子弹。")

    def fire(self):
        if self.bullets > 0:
            print("开火！")
            self.bullets -= 1
            print(f"剩余子弹数量: {self.bullets}")
        else:
            print("没有子弹了，开火失败。")

class Soldier:
    def __init__(self, name):
        self.name = name
        self.weapon = Ak47()

    def reload_weapon(self, num_bullets):
        self.weapon.load_bullets(num_bullets)

    def shoot(self):
        self.weapon.fire()

# 创建士兵瑞恩的实例
ryan = Soldier("瑞恩")

# 装载子弹
ryan.reload_weapon(30)

# 进行射击
for _ in range(35):
    ryan.shoot()
"""